#ifndef BLOG_SERVICE_H
#define BLOG_SERVICE_H

#include "network/epoll_server.h"
#include "database/mysql_pool.h"
#include "cache/redis_client.h"
#include "messaging/kafka_producer.h"
#include "messaging/kafka_consumer.h"
#include <string>
#include <memory>
#include <unordered_map>
#include <nlohmann/json.hpp>

namespace service {
namespace blog {

// 博客文章结构
struct BlogPost {
    int id;
    int userId;
    std::string title;
    std::string content;
    std::string summary;
    int categoryId;
    std::string tags;
    std::string createdAt;
    std::string updatedAt;
    int viewCount;
    int likeCount;
    int commentCount;
    bool isPublished;
    
    // 转换为JSON对象
    nlohmann::json toJson() const;
    
    // 从JSON对象构造
    static BlogPost fromJson(const nlohmann::json& json);
};

// 博客评论结构
struct BlogComment {
    int id;
    int blogId;
    int userId;
    std::string content;
    std::string createdAt;
    int parentId;
    
    // 转换为JSON对象
    nlohmann::json toJson() const;
    
    // 从JSON对象构造
    static BlogComment fromJson(const nlohmann::json& json);
};

// 博客服务类
class BlogService {
public:
    // 创建博客服务
    static std::shared_ptr<BlogService> create(
        std::shared_ptr<database::MySQLPool> dbPool,
        std::shared_ptr<cache::RedisClient> redisClient,
        std::shared_ptr<messaging::KafkaProducer> kafkaProducer = nullptr,
        std::shared_ptr<messaging::KafkaConsumer> kafkaConsumer = nullptr);
    
    // 启动服务
    bool start(int port);
    
    // 停止服务
    void stop();
    
    // 获取所有博客文章（分页）
    std::vector<BlogPost> getAllPosts(int page, int pageSize);
    
    // 获取单篇博客文章
    BlogPost getPostById(int id);
    
    // 创建新博客
    int createPost(const BlogPost& post);
    
    // 更新博客
    bool updatePost(const BlogPost& post);
    
    // 删除博客
    bool deletePost(int id);
    
    // 添加评论
    int addComment(const BlogComment& comment);
    
    // 获取博客评论
    std::vector<BlogComment> getComments(int blogId);
    
    // 点赞博客
    bool likePost(int blogId, int userId);
    
    // 搜索博客
    std::vector<BlogPost> searchPosts(const std::string& keyword, int page, int pageSize);
    
private:
    BlogService(std::shared_ptr<database::MySQLPool> dbPool,
                std::shared_ptr<cache::RedisClient> redisClient,
                std::shared_ptr<messaging::KafkaProducer> kafkaProducer,
                std::shared_ptr<messaging::KafkaConsumer> kafkaConsumer);
    
    // 处理客户端连接
    void handleConnection(std::shared_ptr<network::Connection> conn);
    
    // 处理客户端消息
    void handleMessage(std::shared_ptr<network::Connection> conn, const std::string& message);
    
    // 处理客户端断开连接
    void handleClose(std::shared_ptr<network::Connection> conn);
    
    // 处理API请求
    std::string handleRequest(const std::string& path, const std::string& method, 
                              const nlohmann::json& params);
    
    // 从缓存获取博客
    BlogPost getPostFromCache(int id);
    
    // 将博客存入缓存
    void cachePost(const BlogPost& post);
    
    // 更新博客浏览次数
    void updateViewCount(int blogId);
    
    // 发送事件到Kafka
    void sendEvent(const std::string& eventType, const nlohmann::json& eventData);
    
    // 处理Kafka消息
    void handleKafkaMessage(const std::string& topic, const std::string& key, 
                           const std::string& value, int64_t offset);
    
    // 初始化Kafka消费者
    bool initKafkaConsumer();

private:
    std::shared_ptr<database::MySQLPool> dbPool_;
    std::shared_ptr<cache::RedisClient> redisClient_;
    std::shared_ptr<messaging::KafkaProducer> kafkaProducer_;
    std::shared_ptr<messaging::KafkaConsumer> kafkaConsumer_;
    std::unique_ptr<network::EpollServer> server_;
    bool isRunning_;
};

} // namespace blog
} // namespace service

#endif // BLOG_SERVICE_H 